{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "定义一个三层的全连接网络（FCN），也叫多层感知机（MLP）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:15:22.753116300Z",
     "start_time": "2024-07-31T09:15:22.746410400Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim,hidden_dim=128):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(Model, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_dim, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, action_dim) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "经验回放主要有两个功能，一是存储样本(push)，二是随时采样样本(sample)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:15:24.501440100Z",
     "start_time": "2024-07-31T09:15:24.487458300Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "\n",
    "智能体主要负责与环境交互并更新策略(模型参数)，因此首先需要定义sample_action和predict_action两个函数，前者用于训练时的采样动作，一般会采取$\\varepsilon-\\text{greedy}$策略来提高探索能力，后者一般用于测试算法时的预测动作。其次需要定义update函数，这个函数主要用来从经验回放中采样样本，然后更新模型参数。\n",
    "\n",
    "注意：\n",
    "* 每个张量的维度要对应上，否则可能会报错或者不收敛"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:15:26.557559400Z",
     "start_time": "2024-07-31T09:15:26.551552700Z"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "class Policy:\n",
    "    def __init__(self,cfg):\n",
    "        self.target_update = cfg.target_update\n",
    "        self.action_dim = cfg.action_dim  \n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        # e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end =cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.memory = ReplayBuffer(cfg.buffer_size)\n",
    "        # 当前网络和目标网络\n",
    "        self.policy_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim= cfg.hidden_dim).to(self.device)\n",
    "        self.target_net = Model(cfg.state_dim, cfg.action_dim, hidden_dim= cfg.hidden_dim).to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "            target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.update_cnt = 0 # 用于延迟更新目标网络的计数\n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            with torch.no_grad():\n",
    "                state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "                q_values = self.policy_net(state)\n",
    "                action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        q_values = self.policy_net(state)\n",
    "        action = q_values.max(1)[1].item() # choose action corresponding to the maximum q value\n",
    "        return action\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的样本\n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        actions = torch.tensor(actions, device=self.device).unsqueeze(1)  #  [batch_size, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [batch_size, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batch_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        # 计算当前状态(s_t,a)对应的Q值\n",
    "        q_values = self.policy_net(states).gather(dim=1, index=actions) \n",
    "        # 计算下一时刻的状态(s_t_,a)对应的Q值，注意需要detach()，因为不需要计算梯度\n",
    "        next_q_values_max = self.target_net(next_states).max(1)[0].detach().unsqueeze(1)\n",
    "        # 计算期望的Q值，对于终止状态，此时dones[0]=1, 对应的expected_q_value等于reward\n",
    "        expected_q_values = rewards + self.gamma * next_q_values_max * (1-dones) # [batch_size, 1]\n",
    "         # 计算均方根损失\n",
    "        loss = nn.MSELoss()(q_values, expected_q_values) \n",
    "        # 优化更新模型\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        for param in self.policy_net.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        # 每隔一定步数更新目标网络的参数\n",
    "        if self.update_cnt % self.target_update == 0:\n",
    "            for target_param, param in zip(self.target_net.parameters(),self.policy_net.parameters()): \n",
    "                target_param.data.copy_(param.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:15:29.531145Z",
     "start_time": "2024-07-31T09:15:29.506066Z"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def train(cfg):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id)\n",
    "    setattr(cfg, \"action_space\", env.action_space)\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0])\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n)\n",
    "    policy = Policy(cfg)\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，Epislon：{policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:23:21.470443Z",
     "start_time": "2024-07-31T09:23:21.455438200Z"
    }
   },
   "outputs": [],
   "source": [
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'DQN' # 算法名称\n",
    "        self.env_id = 'Acrobot-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.train_eps = 100 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 2000 # e-greedy策略中epsilon的衰减率\n",
    "        self.buffer_size = 100000 # 经验回放池的容量\n",
    "        self.hidden_dim= 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-31T09:24:13.644708Z",
     "start_time": "2024-07-31T09:23:23.291624Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        DQN         \t   <class 'str'>    \n",
      "       env_id       \t     Acrobot-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "     train_eps      \t        100         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "     max_steps      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        2000        \t   <class 'int'>    \n",
      "    buffer_size     \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/100，奖励：-200.00，Epislon：0.359\n",
      "回合：20/100，奖励：-200.00，Epislon：0.148\n",
      "回合：30/100，奖励：-118.00，Epislon：0.082\n",
      "回合：40/100，奖励：-81.00，Epislon：0.053\n",
      "回合：50/100，奖励：-82.00，Epislon：0.036\n",
      "回合：60/100，奖励：-98.00，Epislon：0.025\n",
      "回合：70/100，奖励：-62.00，Epislon：0.020\n",
      "回合：80/100，奖励：-95.00，Epislon：0.016\n",
      "回合：90/100，奖励：-111.00，Epislon：0.014\n",
      "回合：100/100，奖励：-71.00，Epislon：0.013\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg)\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (joyrl-book)",
   "language": "python",
   "name": "joyrl-book"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
